home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 6 / CU Amiga Magazine's Super CD-ROM 06 (1996)(EMAP Images)(GB)(Track 1 of 4)[!][issue 1997-01].iso / cucd / online / fidonetts / 3csrc.lzh / 3supp.c < prev    next >
C/C++ Source or Header  |  1992-05-01  |  7KB  |  364 lines
  1. /*
  2.  * 3supp.c
  3.  * Public Domain
  4.  *
  5.  * miscellaneous support routines for type 3 ASCII packet manipulation
  6.  * only fgets3 and strdup3 are required; snip and choose as you need
  7.  * from the rest (see below #ifdef NEVER)
  8.  *
  9.  */
  10.  
  11. #include <stddef.h>
  12. #include <stdarg.h>
  13. #include <stdlib.h>
  14. #include <stdio.h>
  15. #include <string.h>
  16. #include <malloc.h>
  17. #include <io.h>
  18. #include <ctype.h>
  19.  
  20. /* A specialized fgets() for type3 ASCII -- stops at <cr>s */
  21.  
  22. char * fgets3 (char *str, int num, int handle) {
  23.  
  24.   char           *p;
  25.   long            pos;
  26.   int             x;
  27.  
  28.   if (eof (handle)) {
  29.     *str = 0;
  30.     return NULL;
  31.   }
  32.   pos = tell (handle);
  33.   x = read(handle,str,num);
  34.   if (x < 1) {
  35.     *str = 0;
  36.     return NULL;
  37.   }
  38.   str[x] = 0;
  39.   p = str;
  40.   while (*p && *p != '\r')
  41.     p++;
  42.   if (!*p)
  43.     return str;
  44.   *p = 0;
  45.   p++;
  46.   lseek (handle, pos + ((int)p - (int)str), SEEK_SET);
  47.   return str;
  48. }
  49.  
  50.  
  51. char * strdup3 (char *dupme) {  /* a strdup */
  52.  
  53.   char *a = NULL;
  54.  
  55.   if(dupme && *dupme) {
  56.     a = (char *)malloc(strlen(dupme) + 1);
  57.     if(a) strcpy(a,dupme);
  58.   }
  59.   return a;
  60. }
  61.  
  62.  
  63. #ifdef NEVER
  64.  
  65. /* not used by 3mailin or 3mailout, but you might find them useful */
  66.  
  67.  
  68. #include <time.h>
  69.  
  70. static char illegal[] = {'\x8d'};  /* anything you want stripped in illegal */
  71.  
  72. int stripjnk3 (char *a,int len) {  /* remove some common 'illegal' chars */
  73.  
  74.   char *p = a;
  75.  
  76.   while (*p) {
  77.     if(*p == '\t') *p = ' ';
  78.     else if ((*p < 31 && *p != '\r') || strchr(illegal,*p)) {
  79.       memmove (p, &p[1], len - ((int) p - (int)a));
  80.       len--;
  81.       if (!len)
  82.         break;
  83.       continue;
  84.     }
  85.     p++;
  86.   }
  87.  
  88.   return len;
  89. }
  90.  
  91.  
  92. char * stripcr3 (char *a) {  /* remove trailing crs */
  93.  
  94.   register int x;
  95.  
  96.   x = strlen (a);
  97.   while (x && a[x - 1] == '\r')
  98.     a[--x] = 0;
  99.   return a;
  100. }
  101.  
  102.  
  103. time_t fido_2_unix (char *str) {
  104.  
  105.   /* translate a fido/sea datestring to a unix timestamp
  106.    * sscanf statements from Folkert Wijnstra via NET_DEV
  107.    */
  108.  
  109.   int             month = 0,
  110.                   day,
  111.                   year,
  112.                   hours,
  113.                   minutes,
  114.                   seconds = 0;
  115.   char            monthStr[20] = "";
  116.  
  117.   if ((sscanf (str, "%d %s %d %d:%d:%d", &day, monthStr, &year,
  118.                &hours, &minutes, &seconds) < 5) &&
  119.       (sscanf (str, "%d-%d-%d %d:%d:%d", &day, &month, &year,
  120.                &hours, &minutes, &seconds) < 5) &&
  121.       (sscanf (&str[4], "%d %s %d %d:%d", &day, monthStr, &year,
  122.                &hours, &minutes) < 5)) {  /* Date not recognized */
  123.     return -1L;
  124.   }
  125.   else {                    /* Date was recognized (convert monthStr to
  126.                              * month if necessary) */
  127.     struct tm       tm;
  128.  
  129.     memset (&tm, 0, sizeof (struct tm));
  130.     if (!month && *monthStr) {
  131.  
  132.       int             x;
  133.       static char    *months[] = {"Jan", "Feb", "Mar", "Apr", "May",
  134.                                   "Jun", "Jul", "Aug", "Sep", "Oct",
  135.                                   "Nov", "Dec"};
  136.  
  137.       for (x = 0; x < 12; x++) {
  138.         if (!strnicmp (monthStr, months[x], 3)) {
  139.           month = x + 1;
  140.           break;
  141.         }
  142.       }
  143.     }
  144.  
  145.     tm.tm_mon = month - 1;
  146.     tm.tm_mday = day;
  147.     if (year > 1900)
  148.       year -= 1900;
  149.     tm.tm_year = year;
  150.     if (hours > 23)
  151.       hours = 0;
  152.     tm.tm_hour = hours;
  153.     tm.tm_min = minutes;
  154.     tm.tm_sec = 0;          /* in case stripped */
  155.  
  156.     return mktime (&tm);
  157.   }
  158. }
  159.  
  160.  
  161. char * unix_2_fido (time_t t,int sea) {
  162.  
  163.   /* translate a unix timestamp to a fido or sea datestring */
  164.  
  165.   static char fdate[22];
  166.  
  167.   if(sea) {
  168.     strftime (fdate, 21, "%a %d %b %y %H:%M", localtime(&t));
  169.     if(fdate[4] == '0') fdate[4] = ' ';
  170.   }
  171.   else {
  172.     strftime (fdate, 21, "%d %b %y  %H:%M:%S", localtime(&t));
  173.   }
  174.   return fdate;
  175. }
  176.  
  177.  
  178. char * unix_2_type3a (time_t t) {
  179.  
  180.   /* translate a unix timestamp to a type3a datestring
  181.    * YYYYMMDDhhmmss -- sortable, compact, unambiguous, ASCII
  182.    */
  183.  
  184.   static char fdate[22];
  185.  
  186.   strftime (fdate, 21, "%Y%m%d%H%M%S", localtime(&t));
  187.   return fdate;
  188. }
  189.  
  190.  
  191. time_t type3a_2_unix (char *a) {
  192.  
  193.   /* translate a type3a datestring to a unix timestamp */
  194.  
  195.     struct tm   tm;
  196.     char        *p,w,*s;
  197.  
  198.     memset (&tm, 0, sizeof (struct tm));
  199.     s = a;
  200.     p = &a[4];
  201.     w = *p;
  202.     *p = 0;
  203.  
  204.     /* note:  if your compiler doesn't have atoi(), emulate w/ sscanf */
  205.  
  206.     tm.tm_year = atoi(s) - 1900;
  207.     *p = w;
  208.     s = p;
  209.     p += 2;
  210.     w = *p;
  211.     *p = 0;
  212.     tm.tm_mon = atoi(s);
  213.     *p = w;
  214.     s = p;
  215.     p += 2;
  216.     w = *p;
  217.     *p = 0;
  218.     tm.tm_mday = atoi(s);
  219.     *p = w;
  220.     s = p;
  221.     p += 2;
  222.     w = *p;
  223.     *p = 0;
  224.     tm.tm_hour = atoi(s);
  225.     *p = w;
  226.     s = p;
  227.     p += 2;
  228.     w = *p;
  229.     *p = 0;
  230.     tm.tm_min = atoi(s);
  231.     *p = w;
  232.     s = p;
  233.     tm.tm_sec = atoi(s);
  234.  
  235.     return mktime (&tm);
  236. }
  237.  
  238.  
  239. char * type3a_2_fido (char *a,int sea) {
  240.  
  241.   /* translate a type3a datestring to a fido or sea datestring */
  242.  
  243.   time_t t;
  244.  
  245.   t = type3a_2_unix(a);
  246.   return unix_2_fido(t,sea);
  247. }
  248.  
  249.  
  250. char * fido_2_type3a (char *a) {
  251.  
  252.   /* translate a fido or sea datestring to a type3a datestring */
  253.  
  254.   time_t t;
  255.  
  256.   t = fido_2_unix(a);
  257.   if(t == -1L) return NULL;
  258.   return unix_2_type3a(t);
  259. }
  260.  
  261.  
  262. struct address {
  263.   unsigned int
  264.         zone,net,node,point;
  265.   char domain[9];
  266. };
  267.  
  268. int parse_addr3 (char *addr3,struct address *addr) {
  269.  
  270.   /* parse a 5-D address from a type 3A From or To address */
  271.  
  272.   char *p,*pp;
  273.  
  274.   memset(addr,0,sizeof(struct address));
  275.   if(!addr3 || !*addr3) return -1;
  276.  
  277.   p = strchr(addr3,'@');
  278.   if(p) p++;
  279.   else p = addr3;
  280.  
  281.   pp = addr->domain;
  282.   while(*p != '#' && pp < addr->domain + 9) {
  283.     *pp = *p;
  284.     pp++;
  285.     p++;
  286.   }
  287.   pp = strchr(addr->domain,'.');
  288.   if(pp) *pp = 0;
  289.   if(!*addr->domain) return -1;
  290.  
  291.   if(*p == '#') p++;
  292.   else {
  293.     p = strchr(p,'#');
  294.     if(!p) return -1;
  295.   }
  296.   addr->zone = atoi(p);
  297.  
  298.   p = strchr(p,':');
  299.   if(!p) return -1;
  300.   p++;
  301.   addr->net = atoi(p);
  302.  
  303.   p = strchr(p,'/');
  304.   if(!p) return -1;
  305.   p++;
  306.   addr->node = atoi(p);
  307.  
  308.   p = strchr(p,'.');
  309.   if(p) {
  310.     p++;
  311.     addr->point = atoi(p);
  312.   }
  313.  
  314.   if(!addr->zone || !addr->net || !*addr->domain) return -1;
  315.  
  316.   return 0;
  317. }
  318.  
  319.  
  320. char * break_id (char *id,char *from,long *serial) {
  321.  
  322.   /*
  323.    * return address portion of id, put serial # in *serial
  324.    * return NULL on error.  not perfect, but works.
  325.    */
  326.  
  327.   static char ret[256];
  328.   char       *p;
  329.  
  330.   if(!id || !*id) return NULL;
  331.  
  332.   if(*id == ' ') {  /* address is same as From */
  333.     if(!from || !*from) return NULL;
  334.     while(*id == ' ') id++;
  335.     *serial = atol(id);
  336.     p = strchr(from,'@');
  337.     if(!p) p = from;
  338.     else p++;
  339.     strcpy(ret,p);
  340.   }
  341.   else {
  342.     if(*id == '\"') {
  343.       p = id + 1;
  344.       while(*p) {
  345.         if(*p == '\"' && *(p + 1) != '\"') break;
  346.         p++;
  347.       }
  348.     }
  349.     else {
  350.       p = strchr(p,' ');
  351.     }
  352.     if(!p || !*p) return NULL;
  353.     else {
  354.       memset(ret,0,256);
  355.       strncpy(ret,id,(int)p - (int)serial);
  356.       while(*p == ' ' || *p == '\"') p++;
  357.       *serial = atol(p);
  358.     }
  359.   }
  360.   return ret;
  361. }
  362.  
  363. #endif
  364.